package com.warom.sdg.util;

import android.util.Log;
import com.warom.sdg.model.PlcDataEntity;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * PLC数据管理器
 * 用于管理PLC实时数据的缓存和更新
 */
public class PlcDataManager {
    private static final String TAG = "PlcDataManager";
    
    // 设备实时数据缓存，结构: Map<deviceId, Map<address, PlcDataEntity>>
    private static final ConcurrentHashMap<Integer, ConcurrentHashMap<String, PlcDataEntity>> realtimeDataCache = new ConcurrentHashMap<>();
    
    /**
     * 更新实时值
     * @param deviceId 设备ID
     * @param address 地址
     * @param data 数据
     */
    public static void updateRealtimeValue(int deviceId, String address, PlcDataEntity data) {
        if (deviceId <= 0 || address == null || address.isEmpty() || data == null) {
            return;
        }
        
        // 获取该设备的数据缓存，如果不存在则创建
        ConcurrentHashMap<String, PlcDataEntity> deviceCache = realtimeDataCache.get(deviceId);
        if (deviceCache == null) {
            deviceCache = new ConcurrentHashMap<>();
            realtimeDataCache.put(deviceId, deviceCache);
        }
        
        // 更新数据
        deviceCache.put(address, data);
        Log.d(TAG, "更新实时数据: 设备=" + deviceId + ", 地址=" + address + ", 值=" + data.getValue());
    }
    
    /**
     * 判断是否有实时值
     * @param deviceId 设备ID
     * @param address 地址
     * @return 是否有实时值
     */
    public static boolean hasRealtimeValue(int deviceId, String address) {
        if (deviceId <= 0 || address == null || address.isEmpty()) {
            return false;
        }
        
        ConcurrentHashMap<String, PlcDataEntity> deviceCache = realtimeDataCache.get(deviceId);
        if (deviceCache == null) {
            return false;
        }
        
        return deviceCache.containsKey(address);
    }
    
    /**
     * 获取实时值
     * @param deviceId 设备ID
     * @param address 地址
     * @return 实时数据，如果不存在则返回null
     */
    public static PlcDataEntity getRealtimeValue(int deviceId, String address) {
        if (deviceId <= 0 || address == null || address.isEmpty()) {
            return null;
        }
        
        ConcurrentHashMap<String, PlcDataEntity> deviceCache = realtimeDataCache.get(deviceId);
        if (deviceCache == null) {
            return null;
        }
        
        return deviceCache.get(address);
    }
    
    /**
     * 清除设备的实时数据缓存
     * @param deviceId 设备ID
     */
    public static void clearDeviceCache(int deviceId) {
        if (deviceId <= 0) {
            return;
        }
        
        realtimeDataCache.remove(deviceId);
        Log.d(TAG, "清除设备实时数据缓存: 设备=" + deviceId);
    }
    
    /**
     * 清除所有实时数据缓存
     */
    public static void clearAllCache() {
        realtimeDataCache.clear();
        Log.d(TAG, "清除所有实时数据缓存");
    }
    
    /**
     * 获取指定设备的所有实时数据
     * @param deviceId 设备ID
     * @return 设备的实时数据Map，如果不存在返回空Map
     */
    public static Map<String, PlcDataEntity> getDeviceRealtimeData(int deviceId) {
        if (deviceId <= 0) {
            return new HashMap<>();
        }
        
        ConcurrentHashMap<String, PlcDataEntity> deviceCache = realtimeDataCache.get(deviceId);
        if (deviceCache == null) {
            return new HashMap<>();
        }
        
        return new HashMap<>(deviceCache);
    }
    
    /**
     * 获取当前缓存的设备数量
     * @return 缓存的设备数量
     */
    public static int getCachedDeviceCount() {
        return realtimeDataCache.size();
    }
    
    /**
     * 获取某设备缓存的测点数量
     * @param deviceId 设备ID
     * @return 缓存的测点数量
     */
    public static int getCachedPointCount(int deviceId) {
        if (deviceId <= 0) {
            return 0;
        }
        
        ConcurrentHashMap<String, PlcDataEntity> deviceCache = realtimeDataCache.get(deviceId);
        if (deviceCache == null) {
            return 0;
        }
        
        return deviceCache.size();
    }
} 